/* OpenSceneGraph example, osgcompositeviewer.
*
*  Permission is hereby granted, free of charge, to any person obtaining a copy
*  of this software and associated documentation files (the "Software"), to deal
*  in the Software without restriction, including without limitation the rights
*  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
*  copies of the Software, and to permit persons to whom the Software is
*  furnished to do so, subject to the following conditions:
*
*  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
*  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
*  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
*  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
*  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
*  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
*  THE SOFTWARE.
*/

#include <iostream>

#include <osgUtil/Optimizer>
#include <osgDB/ReadFile>

#include <osg/Material>
#include <osg/Geode>
#include <osg/BlendFunc>
#include <osg/Depth>
#include <osg/Projection>
#include <osg/PolygonOffset>
#include <osg/MatrixTransform>
#include <osg/Camera>
#include <osg/FrontFace>

#include <osgText/Text>

#include <osgGA/TrackballManipulator>
#include <osgGA/FlightManipulator>
#include <osgGA/StateSetManipulator>
#include <osgViewer/ViewerEventHandlers>

#include <osgViewer/CompositeViewer>

#include <osgFX/Scribe>

#include <osg/io_utils>

// class to handle events with a pick
class PickHandler : public osgGA::GUIEventHandler {
public:

    PickHandler():
        _mx(0.0f),
        _my(0.0f) {}

    ~PickHandler() {}

    bool handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& aa)
    {
        osgViewer::View* view = dynamic_cast<osgViewer::View*>(&aa);
        if (!view) return false;

        switch(ea.getEventType())
        {
            case(osgGA::GUIEventAdapter::PUSH):
            {
                _mx = ea.getX();
                _my = ea.getY();
                break;
            }
            case(osgGA::GUIEventAdapter::RELEASE):
            {
                if (_mx==ea.getX() && _my==ea.getY())
                {
                    pick(view, ea.getX(), ea.getY());
                }
                break;
            }
            default:
                break;
        }
        return false;
    }

    void pick(osgViewer::View* view, float x, float y)
    {
        osg::Node* node = 0;
        osg::Group* parent = 0;

        osgUtil::LineSegmentIntersector::Intersections intersections;
        if (view->computeIntersections(x, y, intersections))
        {
            osgUtil::LineSegmentIntersector::Intersection intersection = *intersections.begin();
            osg::NodePath& nodePath = intersection.nodePath;
            node = (nodePath.size()>=1)?nodePath[nodePath.size()-1]:0;
            parent = (nodePath.size()>=2)?dynamic_cast<osg::Group*>(nodePath[nodePath.size()-2]):0;
        }

        // now we try to decorate the hit node by the osgFX::Scribe to show that its been "picked"
        if (parent && node)
        {

            osgFX::Scribe* parentAsScribe = dynamic_cast<osgFX::Scribe*>(parent);
            if (!parentAsScribe)
            {
                // node not already picked, so highlight it with an osgFX::Scribe
                osgFX::Scribe* scribe = new osgFX::Scribe();
                scribe->addChild(node);
                parent->replaceChild(node,scribe);
            }
            else
            {
                // node already picked so we want to remove scribe to unpick it.
                osg::Node::ParentList parentList = parentAsScribe->getParents();
                for(osg::Node::ParentList::iterator itr=parentList.begin();
                    itr!=parentList.end();
                    ++itr)
                {
                    (*itr)->replaceChild(parentAsScribe,node);
                }
            }
        }

    }

    float _mx, _my;

};
osg::Geode* renderWorldReference()
{
//learn how to render point, line, and others
    osg::Geode* pAxisGeode = new osg::Geode();
    osg::Geometry* pAxisGeometry = new osg::Geometry();

    pAxisGeode->addDrawable(pAxisGeometry);
   
    osg::Vec3Array* pAxis = new osg::Vec3Array;
    pAxis->push_back( osg::Vec3(  0,0,0 ) );
    pAxis->push_back( osg::Vec3( 10,0,0 ) );
    pAxis->push_back( osg::Vec3( 0,10,0 ) );   
    pAxis->push_back( osg::Vec3( 0,0,10 ) );

    pAxisGeometry->setVertexArray( pAxis );
    //render x 
    osg::DrawElementsUInt* pAxisX = new osg::DrawElementsUInt(osg::PrimitiveSet::LINES, 0);
    pAxisX->push_back(0);
    pAxisX->push_back(1);
    pAxisGeometry->addPrimitiveSet(pAxisX);
    //render y 
    osg::DrawElementsUInt* pAxisY = new osg::DrawElementsUInt(osg::PrimitiveSet::LINES, 0);
    pAxisY->push_back(0);
    pAxisY->push_back(2);
    pAxisGeometry->addPrimitiveSet(pAxisY);
     //render z 
    osg::DrawElementsUInt* pAxisZ = new osg::DrawElementsUInt(osg::PrimitiveSet::LINES, 0);
    pAxisZ->push_back(0);
    pAxisZ->push_back(3);
    pAxisGeometry->addPrimitiveSet(pAxisZ);
    // set line width
    osg::StateSet* pStateSet = new osg::StateSet;
    osg::LineWidth* pLineWidth = new osg::LineWidth();
    pLineWidth->setWidth(10.0f);
    pStateSet->setAttributeAndModes(pLineWidth,osg::StateAttribute::ON);
    pStateSet->setMode(GL_LIGHTING,osg::StateAttribute::OFF);
    pAxisGeometry->setStateSet(pStateSet);
    //color
    osg::Vec4Array* pAxisColors = new osg::Vec4Array;
    //pAxisColors->push_back(osg::Vec4(1.0f, 1.0f, 1.0f, 1.0f) ); //index 0 white
    pAxisColors->push_back(osg::Vec4(1.0f, 0.0f, 0.0f, 1.0f) ); //index 1 red
    pAxisColors->push_back(osg::Vec4(0.0f, 1.0f, 0.0f, 1.0f) ); //index 2 green
    pAxisColors->push_back(osg::Vec4(0.0f, 0.0f, 1.0f, 1.0f) ); //index 3 blue

    //The next step is to associate the array of colors with the geometry,
    //assign the color indices created above to the geometry and set the
    //binding mode to _PER_VERTEX.
    pAxisGeometry->setColorArray(pAxisColors);
    pAxisGeometry->setColorBinding(osg::Geometry::BIND_PER_PRIMITIVE);

    return pAxisGeode;
}


int main( int argc, char **argv )
{

    // use an ArgumentParser object to manage the program arguments.
    osg::ArgumentParser arguments(&argc,argv);

    // read the scene from the list of file specified commandline args.
    osg::ref_ptr<osg::Node> scene = osgDB::readNodeFiles(arguments);

    if (!scene)
    {
        std::cout << argv[0] << ": requires filename argument." << std::endl;
        return 1;
    }

    //define graphics context
    osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;
    traits->x = 100;
    traits->y = 100;
    traits->width = 1000;
    traits->height = 800;
    traits->windowDecoration = true;
    traits->doubleBuffer = true;
    traits->sharedContext = 0;

    osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());
    if (gc.valid())
    {
        osg::notify(osg::INFO)<<"  GraphicsWindow has been created successfully."<<std::endl;

        // need to ensure that the window is cleared make sure that the complete window is set the correct colour
        // rather than just the parts of the window that are under the camera's viewports
        gc->setClearColor(osg::Vec4f(0.2f,0.2f,0.6f,1.0f));
        gc->setClearMask(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    }
    else
    {
        osg::notify(osg::NOTICE)<<"  GraphicsWindow has not been created successfully."<<std::endl;
    }

    // construct the viewer.
    osgViewer::CompositeViewer viewer;
    while (arguments.read("-s")) { viewer.setThreadingModel(osgViewer::CompositeViewer::SingleThreaded); }
    while (arguments.read("-g")) { viewer.setThreadingModel(osgViewer::CompositeViewer::CullDrawThreadPerContext); }
    while (arguments.read("-c")) { viewer.setThreadingModel(osgViewer::CompositeViewer::CullThreadPerCameraDrawThreadPerContext); }

    // viewport one
    {
        osgViewer::View* view = new osgViewer::View;
        view->setName("View one");
        viewer.addView(view);

        osg::Group* root = new osg::Group();// a 'group' instance to serve as the root of the scene graph

        //render world reference system
        root->addChild(renderWorldReference());
        root->addChild(scene.get());


        view->getCamera()->setName("Cam one");
        view->getCamera()->setViewport(new osg::Viewport(0,0, traits->width/2, traits->height/2));
        view->getCamera()->setGraphicsContext(gc.get());
        view->setCameraManipulator(new osgGA::TrackballManipulator);
        view->setSceneData(root);

        // add the state manipulator
        osg::ref_ptr<osgGA::StateSetManipulator> statesetManipulator = new osgGA::StateSetManipulator;
        statesetManipulator->setStateSet(view->getCamera()->getOrCreateStateSet());

        view->addEventHandler( statesetManipulator.get() );

        view->addEventHandler( new osgViewer::StatsHandler );
        view->addEventHandler( new osgViewer::HelpHandler );
        view->addEventHandler( new osgViewer::WindowSizeHandler );
        view->addEventHandler( new osgViewer::ThreadingHandler );
        view->addEventHandler( new osgViewer::RecordCameraPathHandler );
    }

    // viewport two
    {
        osgViewer::View* view = new osgViewer::View;
        view->setName("View two");
        viewer.addView(view);

        view->setSceneData(scene.get());
        view->getCamera()->setName("Cam two");
        view->getCamera()->setViewport(new osg::Viewport(traits->width/2,0, traits->width/2, traits->height/2));
        view->getCamera()->setGraphicsContext(gc.get());
        view->setCameraManipulator(new osgGA::TrackballManipulator);

        // add the handler for doing the picking
        view->addEventHandler(new PickHandler());

    }

    // viewport three
    {
        osgViewer::View* view = new osgViewer::View;
        view->setName("View three");
        viewer.addView(view);

        view->setSceneData(osgDB::readNodeFile("cessnafire.osgt"));

        view->getCamera()->setName("Cam three");
        view->getCamera()->setProjectionMatrixAsPerspective(30.0, double(traits->width) / double(traits->height/2), 1.0, 1000.0);
        view->getCamera()->setViewport(new osg::Viewport(0, traits->height/2, traits->width, traits->height/2));
        view->getCamera()->setGraphicsContext(gc.get());
        view->setCameraManipulator(new osgGA::TrackballManipulator);
    }


     // run the viewer's main frame loop
     return viewer.run();
}

